import java.util.*;

public class Test {
    public static void main1(String[] args) {
        StringBuilder stringBuilder = new StringBuilder("[" + "a" + "]");
        System.out.println(stringBuilder.toString());
    }

    // 题目1 IP 地址无效化
//    给你一个有效的 IPv4 地址 address，返回这个 IP 地址的无效化版本。
//    所谓无效化 IP 地址，其实就是用 "[.]" 代替了每个 "."

    public String defangIPaddr(String address) {
        int n = address.length();
        StringBuilder stringBuilder = new StringBuilder();
        for(int i = 0; i < n; i++){
            char c = address.charAt(i);
            if(c == '.'){
                stringBuilder.append('[');
            }
            stringBuilder.append(c);
            if(c == '.'){
                stringBuilder.append(']');
            }
        }
        return stringBuilder.toString();
    }

    public String defangIPaddr1(String address) {
        return address.replaceAll("\\.","[.]");
    }

    // 题目2 ： N 字型变换
    //将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。
    public String convert(String s, int numRows) {
        if(numRows < 2){
            return s;
        }
        List<StringBuilder> rows = new ArrayList<>();
        for(int i = 0; i < numRows; i++){
            rows.add(new StringBuilder());
        }
        int i = 0;
        int flag = -1;
        for(char x : s.toCharArray()){
            rows.get(i).append(x);
            if(i == 0 || i == numRows - 1){
                flag = -flag;
            }
            i += flag;
        }
        StringBuilder res = new StringBuilder();
        for(StringBuilder row : rows){
            res.append(row);
        }
        return res.toString();
    }

    // 题目3 ：移动所有球到每一个盒子所需的最小操作数
    // 有 n 个盒子。给你一个长度为 n 的二进制字符串 boxes ，其中 boxes[i] 的值为 '0' 表示第 i 个盒子是 空 的，而 boxes[i] 的值为 '1' 表示盒子里有 一个 小球。
    //
    //在一步操作中，你可以将 一个 小球从某个盒子移动到一个与之相邻的盒子中。第 i 个盒子和第 j 个盒子相邻需满足 abs(i - j) == 1 。注意，操作执行后，某些盒子中可能会存在不止一个小球。
    //
    //返回一个长度为 n 的数组 answer ，其中 answer[i] 是将所有小球移动到第 i 个盒子所需的 最小 操作数。
    //
    //每个 answer[i] 都需要根据盒子的 初始状态 进行计算
    // 时间复杂度 O（n²）
    public int[] minOperations1(String boxes) {
        char[] ch = boxes.toCharArray();
        int n = ch.length;
        int[] res = new int[n];
        for(int i = 0; i < n; i++){
            for(int j = 0; j < i; j++){
                if(ch[j] == '1'){
                    res[i] += i - j;
                }
            }

            for(int k = i + 1; k < n; k++){
                if(ch[k] == '1'){
                    res[i] += k - i;
                }
            }
        }
        return res;
    }

    public int[] minOperations2(String boxes) {
        char[] ch = boxes.toCharArray();
        int n = ch.length;
        int[] res = new int[n];
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                if(ch[j] == '1'){
                    res[i] += Math.abs(i - j);
                }
            }
        }
        return res;
    }

    // 时间复杂度 O（n）
    public int[] minOperations(String boxes) {
        char[] ch = boxes.toCharArray();
        int n = ch.length;
        int left = ch[0] - '0';
        int right = 0;
        int operation = 0;
        // 0下标盒子所需的最小操作数
        for(int i = 1; i < n; i++){
            if(ch[i] == '1'){
                right++;
                operation += i;
            }
        }
        int[] dp = new int[n];
        dp[0] = operation;
        for(int i = 1; i < n; i++){
            dp[i] = dp[i - 1] + left - right;
            if(ch[i] == '1'){
                left++;
                right--;
            }
        }
        return dp;
    }


}

